import { NextRequest, NextResponse } from 'next/server';
import { prisma } from '@/lib/db';
import { hash, compare } from 'bcrypt';

export async function POST(request: NextRequest) {
  try {
    const data = await request.json();
    const { email, code, password } = data;
    
    if (!email || !code || !password) {
      return NextResponse.json(
        { success: false, message: '邮箱、验证码和密码不能为空' },
        { status: 400 }
      );
    }

    // 验证密码长度
    if (password.length < 8) {
      return NextResponse.json(
        { success: false, message: '密码长度必须至少为8个字符' },
        { status: 400 }
      );
    }

    // 查找用户和重置令牌
    const user = await prisma.user.findUnique({
      where: { email },
      include: { passwordReset: true }
    });

    if (!user || !user.passwordReset) {
      return NextResponse.json(
        { success: false, message: '无效的邮箱或用户不存在' },
        { status: 400 }
      );
    }

    // 验证重置码
    if (user.passwordReset.token !== code) {
      return NextResponse.json(
        { success: false, message: '验证码不正确' },
        { status: 400 }
      );
    }

    // 检查验证码是否过期
    if (user.passwordReset.expires < new Date()) {
      return NextResponse.json(
        { success: false, message: '验证码已过期，请重新获取' },
        { status: 400 }
      );
    }

    // 如果用户已有密码，检查新密码是否与当前密码相同
    if (user.password) {
      try {
        const isSamePassword = await compare(password, user.password);
        if (isSamePassword) {
          return NextResponse.json(
            { success: false, message: '新密码不能与当前密码相同' },
            { status: 400 }
          );
        }
      } catch (error) {
        console.error('密码比对失败:', error);
      }
    }

    // 检查密码历史，防止使用最近的5个密码
    const passwordHistory = await prisma.passwordHistory.findMany({
      where: { userId: user.id },
      orderBy: { createdAt: 'desc' },
      take: 5
    });

    // 检查新密码是否与历史密码相同
    for (const historyItem of passwordHistory) {
      try {
        const isSameAsHistory = await compare(password, historyItem.password);
        if (isSameAsHistory) {
          return NextResponse.json(
            { success: false, message: '新密码不能与最近使用过的密码相同' },
            { status: 400 }
          );
        }
      } catch (error) {
        console.error('密码历史比对失败:', error);
      }
    }

    // 哈希新密码
    const hashedPassword = await hash(password, 10);

    // 保存新密码历史记录
    await prisma.passwordHistory.create({
      data: {
        userId: user.id,
        password: hashedPassword
      }
    });

    // 更新用户密码
    await prisma.user.update({
      where: {
        id: user.id
      },
      data: {
        password: hashedPassword
      }
    });

    // 删除已使用的重置令牌
    await prisma.passwordReset.delete({
      where: {
        id: user.passwordReset.id
      }
    });

    return NextResponse.json({ success: true, message: '密码重置成功' });
  } catch (error) {
    console.error('重置密码失败:', error);
    return NextResponse.json(
      { success: false, message: '重置密码失败' },
      { status: 500 }
    );
  }
} 